/*
 * @Description:
 * @Author: dh
 * @Date: 2021-08-19 17:18:39
 * @LastEditors: dh
 * @LastEditTime: 2025-09-10 14:00:53
 */
// Promise.resolve(x)
// 如果 x 是 Promise 实例本身，则抛出错误
// 如果 x 是一个 Promise 对象，那么 then 函数的执行取决这个 x 的状态，如果 x 也调用 resolve(y),其中 y 也是一个 promise 对象.那么 then 函数的执行取决于这个 promise 对象，依次类推，直到最后一个 promise 状态更改
// 如果 x 是一个 thenable 对象，就是一个对象包含 then 这个属性，或者是一个函数包含一个 then 的静态方法,那么直接执行 then 函数,并返回
// 如果 x 是一个普通值，直接变成 onFulfilled 状态，执行后面的 then 函数

Promise.resolve = function (value) {
	if (value instanceof Promise) {
		return value
	}
	if (typeof value === 'object' && typeof value.then === 'function') {
		return new Promise(resolve => {
			value.then(resolve)
		})
	}
	return new Promise(resolve => resolve(value))
}

// Promise.reject() 会实例化一个 rejected 状态的 Promise。
// 但与 Promise.resolve() 不同的是，如果给 Promise.reject() 传递一个 Promise 对象，则这个对象会成为新 Promise 的值。
Promise.reject = function (reason) {
	return new Promise((resolve, reject) => reject(reason))
}

Promise.prototype.catch = function (fn) {
	return this.then(undefined, fn)
}

// 传入的所有 Promise 都是 fulfilled，则返回由他们的值组成的，状态为 fulfilled 的新 Promise；
// 只要有一个 Promise 是 rejected，则返回 rejected 状态的新 Promsie，且它的值是第一个 rejected 的 Promise 的值；
// 只要有一个 Promise 是 pending，则返回一个 pending 状态的新 Promise；
Promise.all = function (promiseArr) {
	let index = 0
	let result = []
	return new Promise((resolve, reject) => {
		promiseArr.forEach((p, i) => {
			Promise.resolve(p).then(
				val => {
					index++
					result[i] = val
					if (index === promiseArr.length) {
						resolve(result)
					}
				},
				err => {
					reject(err)
				}
			)
		})
	})
}

// Promise.race 会返回一个由所有可迭代实例中第一个 fulfilled 或 rejected 的实例包装后的新实例。
Promise.race = function (promiseArr) {
	return new Promise((resolve, reject) => {
		promiseArr.forEach(p => {
			Promise.resolve(p).then(
				val => {
					resolve(val)
				},
				err => {
					reject(err)
				}
			)
		})
	})
}

Promise.prototype.finally = function (onFinally) {
	return this.then(
		/* onFulfilled */
		res => Promise.resolve(onFinally()).then(() => res),
		/* onRejected */
		err =>
			Promise.resolve(onFinally()).then(() => {
				throw err
			})
	)
}

//  只要有成功的，就立即返回 结果 。都失败就返回 全部失败的提示
Promise.any = promiseArray => {
	return new Promise((resolve, reject) => {
		const rejectedArray = []
		promiseArray.forEach(item => {
			Promise.resolve(item).then(
				val => {
					resolve(val)
				},
				reason => {
					rejectedArray.push(reason)
					if (rejectedArray.length === promiseArray.length) {
						// AggregateError 对象代表了包装了多个错误对象的单个错误对象。当一个操作需要报告多个错误时，例如 Promise.any()，当传递给它的所有承诺都被拒绝时，就会抛出该错误。
						reject(new AggregateError(rejectedArray))
					}
				}
			)
		})
	})
}
